import axios from 'axios'
import { ElMessage } from 'element-plus'
import request from "@/utils/request";

export const basePythonURL = 'http://192.168.0.152:5001/api'
export const basePythonURL2 = 'http://192.168.0.152:5001'

// 创建axios实例
const api = axios.create({
    baseURL: basePythonURL,
    timeout: 60000,
    headers: {
        'Content-Type': 'application/json'
    }
})

// 请求拦截器
api.interceptors.request.use(
    config => {
        // 在发送请求之前做些什么
        return config
    },
    error => {
        return Promise.reject(error)
    }
)

// 响应拦截器
api.interceptors.response.use(
    response => {
        return response.data
    },
    error => {
        console.error('API请求错误:', error)

        let message = '请求失败'
        if (error.response) {
            // 服务器返回错误状态码
            message = error.response.data?.message || `请求失败 (${error.response.status})`
        } else if (error.request) {
            // 请求已发出但没有收到响应
            message = '网络连接失败，请检查网络状态'
        } else {
            // 其他错误
            message = error.message || '未知错误'
        }

        ElMessage.error(message)
        return Promise.reject(error)
    }
)

export default {
    // ================ 训练相关 ===================
    // 训练相关API
    startTraining(params){
        return api.post('/start-training' , params)
    },

    // 批量训练API
    async batchTraining(tasks, onProgress) {
        const results = {
            successCount: 0,
            failedCount: 0,
            totalCount: tasks.length,
            details: []
        }

        for (let i = 0; i < tasks.length; i++) {
            const task = tasks[i]

            try {
                // 更新进度
                if (onProgress) {
                    onProgress({
                        current: i + 1,
                        total: tasks.length,
                        currentTask: task,
                        percentage: Math.round(((i + 1) / tasks.length) * 100)
                    })
                }

                const result = await this.startTraining({
                    taskId: task.task_id,
                    videoPath: task.result_path,
                    primaryCategoryId: task.category.primary,
                    secondaryCategoryId: task.category.secondary,
                    tertiaryCategoryId: task.category.tertiary || 0,
                    modelName: task.output_name,
                })

                if (result.success) {
                    results.successCount++
                    results.details.push({
                        taskId: task.task_id,
                        taskName: task.output_name,
                        status: 'success',
                        voiceId: result.voiceId
                    })
                } else {
                    results.failedCount++
                    results.details.push({
                        taskId: task.task_id,
                        taskName: task.output_name,
                        status: 'failed',
                        error: result.message
                    })
                }
            } catch (error) {
                results.failedCount++
                results.details.push({
                    taskId: task.task_id,
                    taskName: task.output_name,
                    status: 'error',
                    error: error.message
                })
            }
        }

        return results
    },

    // 分类相关API
    getCategoryTree(){
        return request({
            url: '/api/category/tree',
            method: 'get'
        })
    },

    getSubCategories(parentId) {
        return request({
            url: `/api/category/sub/${parentId}`,
            method: 'get'
        })
    },

    addCategory(name, parentId, level) {
        return request({
            url: '/api/category/add',
            method: 'post',
            data: {
                name,
                parentId,
                level
            }
        })
    },

    deleteCategory(categoryId) {
        return request({
            url: `/api/category/delete/${categoryId}`,
            method: 'post'
        })
    },


    // ================ 文件上传相关 ================

    /**
     * 上传文件
     * @param {File} file - 文件对象
     * @param {string} type - 文件类型 ('human' | 'background')
     * @returns {Promise}
     */
    async uploadFile(file, type) {
        const formData = new FormData()
        formData.append('file', file)
        formData.append('type', type)

        return api.post('/upload', formData, {
            headers: {
                'Content-Type': 'multipart/form-data'
            }
        })
    },

    // 批量上传文件
    batchUploadFiles(files, type) {
        const promises = files.map(file => this.uploadFile(file, type))
        return Promise.all(promises)
    },

    // ================ 分片上传 (推荐用于大文件) ================

    /**
     * 初始化分片上传
     * @param {Object} options - 上传选项
     * @param {string} options.filename - 文件名
     * @param {number} options.fileSize - 文件大小
     * @param {string} options.fileType - 文件类型
     * @param {number} options.chunkSize - 分片大小 (默认5MB)
     * @returns {Promise}
     */
    initChunkedUpload({ filename, fileSize, fileType, chunkSize = 5 * 1024 * 1024 }) {
        return api.post('/upload/init', {
            filename,
            fileSize,
            fileType,
            chunkSize
        })
    },

    /**
     * 上传分片
     * @param {Object} options - 上传选项
     * @param {string} options.uploadId - 上传会话ID
     * @param {number} options.chunkIndex - 分片索引
     * @param {Blob} options.chunkData - 分片数据
     * @returns {Promise}
     */
    uploadChunk({ uploadId, chunkIndex, chunkData }) {
        const formData = new FormData()
        formData.append('uploadId', uploadId)
        formData.append('chunkIndex', chunkIndex)
        formData.append('chunk', chunkData)

        return api.post('/upload/chunk', formData, {
            headers: {
                'Content-Type': 'multipart/form-data'
            },
            timeout: 60000 // 1分钟超时
        })
    },

    /**
     * 完成分片上传
     * @param {string} uploadId - 上传会话ID
     * @returns {Promise}
     */
    completeChunkedUpload(uploadId) {
        return api.post('/upload/complete', { uploadId })
    },

    /**
     * 取消分片上传
     * @param {string} uploadId - 上传会话ID
     * @returns {Promise}
     */
    cancelChunkedUpload(uploadId) {
        return api.post('/upload/cancel', { uploadId })
    },

    /**
     * 获取上传状态
     * @param {string} uploadId - 上传会话ID
     * @returns {Promise}
     */
    getUploadStatus(uploadId) {
        return api.get(`/upload/status/${uploadId}`)
    },

    // ================ 库文件管理相关 ================

    /**
     * 获取库文件列表
     * @param {string} type - 文件类型 ('human' | 'background' | 'all')
     * @param {number} page - 页码
     * @param {number} pageSize - 每页数量
     * @param {object} options - 可选参数
     * @returns {Promise}
     */
    async getLibraryFiles(type = 'all', page = 1, pageSize = 12, options = {}) {
        const params = {
            type,
            page,
            pageSize,
            ...options
        }

        return api.get('/library', { params })
    },

    /**
     * 删除库文件
     * @param {string} fileId - 文件ID
     * @returns {Promise}
     */
    async deleteLibraryFile(fileId) {
        return api.delete(`/library/${fileId}`)
    },

    /**
     * 批量删除库文件
     * @param {string[]} fileIds - 文件ID数组
     * @returns {Promise}
     */
    async batchDeleteLibraryFiles(fileIds) {
        return api.post('/library/batch-delete', { fileIds })
    },

    /**
     * 获取文件预览
     * @param {string} fileId - 文件ID
     * @returns {string} 预览URL
     */
    getPreviewUrl(fileId) {
        return `${api.defaults.baseURL}/preview-file/${fileId}`
    },

    // ================ 预览相关 ================

    /**
     * 生成参数预览
     * @param {string} humanFileId - 数字人文件ID
     * @param {string} backgroundFileId - 背景文件ID
     * @param {object} params - 参数对象
     * @returns {Promise}
     */
    async generatePreview(humanFileId, backgroundFileId, params) {
        return api.post('/generate-preview', {
            human_file_id: humanFileId,
            background_file_id: backgroundFileId,
            params
        })
    },

    /**
     * 清除预览
     * @param {string} previewId - 预览ID
     * @returns {Promise}
     */
    async clearPreview(previewId) {
        return api.delete(`/clear-preview/${previewId}`)
    },

    /**
     * 清除所有预览
     * @returns {Promise}
     */
    async clearAllPreviews() {
        return api.delete('/clear-all-previews')
    },

    // ================ 视频处理相关 ================

    /**
     * 处理单个视频
     * @param {object} data - 处理参数
     * @returns {Promise}
     */
    async processVideo(data) {
        const formData = new FormData()

        // 添加参数到FormData
        Object.keys(data).forEach(key => {
            formData.append(key, data[key])
        })

        return api.post('/process-video', formData, {
            headers: {
                'Content-Type': 'multipart/form-data'
            }
        })
    },

    /**
     * 批量处理视频
     * @param {object} data - 批量处理参数
     * @returns {Promise}
     */
    async batchProcess(data) {
        return api.post('/batch-process', data)
    },

    /**
     * 获取任务状态
     * @param {string} taskId - 任务ID
     * @returns {Promise}
     */
    async getTaskStatus(taskId) {
        return api.get(`/task-status/${taskId}`)
    },

    /**
     * 获取批量任务状态
     * @param {string} batchId - 批量任务ID
     * @returns {Promise}
     */
    async getBatchStatus(batchId) {
        return api.get(`/batch-status/${batchId}`)
    },

    /**
     * 下载处理结果
     * @param {string} filename - 文件名
     * @returns {string} 下载URL
     */
    getDownloadUrl(filename) {
        return `${api.defaults.baseURL}/download/${filename}`
    },

    // 下载文件
    downloadFile(filename) {
        window.open(`${api.defaults.baseURL}/download/${filename}`)
    },

    // ================ 历史记录相关 ================

    /**
     * 获取处理历史
     * @param {object} params - 查询参数
     * @returns {Promise}
     */
    async getHistory(params = {}) {
        return api.get('/history', { params })
    },

    /**
     * 删除历史记录
     * @param {string} taskId - 任务ID
     * @returns {Promise}
     */
    async deleteHistory(taskId) {
        return api.delete(`/history/${taskId}`)
    },

    /**
     * 批量删除历史记录
     * @param {string[]} taskIds - 任务ID数组
     * @returns {Promise}
     */
    async batchDeleteHistory(taskIds) {
        return api.post('/history/batch-delete', { taskIds })
    },

    /**
     * 获取历史统计信息
     * @returns {Promise}
     */
    async getHistoryStats() {
        return api.get('/history/stats')
    },

    /**
     * 获取任务预览图
     * @param {string} taskId - 任务ID
     * @returns {string} 预览URL
     */
    getTaskPreviewUrl(taskId) {
        return `${api.defaults.baseURL}/task-preview/${taskId}`
    },

    // ================ 预设管理相关 ================

    /**
     * 获取预设列表
     * @returns {Promise}
     */
    async getPresets() {
        return api.get('/presets')
    },

    /**
     * 获取单个预设
     * @param {number} presetId - 预设ID
     * @returns {Promise}
     */
    async getPreset(presetId) {
        return api.get(`/presets/${presetId}`)
    },

    /**
     * 保存预设（新建或更新）
     * @param {object} presetData - 预设数据
     * @returns {Promise}
     */
    async savePreset(presetData) {
        return api.post('/presets', presetData)
    },

    /**
     * 删除预设
     * @param {number} presetId - 预设ID
     * @returns {Promise}
     */
    async deletePreset(presetId) {
        return api.delete(`/presets/${presetId}`)
    },

    /**
     * 复制预设
     * @param {number} presetId - 原预设ID
     * @returns {Promise}
     */
    async duplicatePreset(presetId) {
        return api.post(`/presets/duplicate/${presetId}`)
    },

    /**
     * 导出预设
     * @returns {Promise}
     */
    async exportPresets() {
        return api.get('/presets/export')
    },

    /**
     * 导入预设
     * @param {object[]} presets - 预设数组
     * @returns {Promise}
     */
    async importPresets(presets) {
        return api.post('/presets/import', { presets })
    },

    // ================ 系统管理相关 ================

    /**
     * 健康检查
     * @returns {Promise}
     */
    async healthCheck() {
        return api.get('/health')
    },

    /**
     * 手动清理
     * @param {object} options - 清理选项
     * @returns {Promise}
     */
    async manualCleanup(options = {}) {
        return api.post('/cleanup', options)
    },

    /**
     * 获取系统信息
     * @returns {Promise}
     */
    async getSystemInfo() {
        return api.get('/info')
    },

    /**
     * 获取系统统计
     * @returns {Promise}
     */
    async getSystemStats() {
        return api.get('/stats')
    },

    /**
     * 获取系统日志
     * @param {object} params - 查询参数
     * @returns {Promise}
     */
    async getSystemLogs(params = {}) {
        return api.get('/logs', { params })
    },

    // ================ 工具方法 ================

    /**
     * 格式化文件大小
     * @param {number} bytes - 字节数
     * @returns {string} 格式化后的大小
     */
    formatFileSize(bytes) {
        if (bytes === 0) return '0 Bytes'
        const k = 1024
        const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB']
        const i = Math.floor(Math.log(bytes) / Math.log(k))
        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
    },

    /**
     * 格式化日期时间
     * @param {string|Date} date - 日期
     * @returns {string} 格式化后的日期
     */
    formatDateTime(date) {
        if (!date) return '未知'
        try {
            return new Date(date).toLocaleString('zh-CN')
        } catch {
            return '无效日期'
        }
    },

    /**
     * 获取文件类型
     * @param {string} filename - 文件名
     * @returns {string} 文件类型
     */
    getFileType(filename) {
        if (!filename) return 'unknown'
        const ext = filename.split('.').pop().toLowerCase()

        if (['jpg', 'jpeg', 'png', 'webp', 'bmp'].includes(ext)) return 'image'
        if (['gif'].includes(ext)) return 'gif'
        if (['mp4', 'mov', 'avi', 'mkv', 'wmv'].includes(ext)) return 'video'
        if (['mp3', 'wav', 'flac', 'aac'].includes(ext)) return 'audio'

        return 'unknown'
    },

    /**
     * 检查文件是否为视频
     * @param {string} filename - 文件名
     * @returns {boolean}
     */
    isVideoFile(filename) {
        return this.getFileType(filename) === 'video'
    },

    /**
     * 检查文件是否为图片
     * @param {string} filename - 文件名
     * @returns {boolean}
     */
    isImageFile(filename) {
        const type = this.getFileType(filename)
        return type === 'image' || type === 'gif'
    },

    /**
     * 生成唯一ID
     * @returns {string}
     */
    generateId() {
        return Math.random().toString(36).substring(2) + Date.now().toString(36)
    },

    /**
     * 防抖函数
     * @param {Function} func - 要防抖的函数
     * @param {number} wait - 等待时间
     * @returns {Function}
     */
    debounce(func, wait) {
        let timeout
        return function executedFunction(...args) {
            const later = () => {
                clearTimeout(timeout)
                func(...args)
            }
            clearTimeout(timeout)
            timeout = setTimeout(later, wait)
        }
    },

    /**
     * 节流函数
     * @param {Function} func - 要节流的函数
     * @param {number} limit - 时间限制
     * @returns {Function}
     */
    throttle(func, limit) {
        let inThrottle
        return function executedFunction(...args) {
            if (!inThrottle) {
                func.apply(this, args)
                inThrottle = true
                setTimeout(() => inThrottle = false, limit)
            }
        }
    }
}